#region License
//
// The Open Toolkit Library License
//
// Copyright (c) 2006 - 2009 the Open Toolkit library.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights to 
// use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
// the Software, and to permit persons to whom the Software is furnished to do
// so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
// OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
// OTHER DEALINGS IN THE SOFTWARE.
//
#endregion

namespace OpenTK.Graphics.ES11
{
    using System;
    using System.Runtime.InteropServices;
    #pragma warning disable 3019
    #pragma warning disable 1591
    #pragma warning disable 1572
    #pragma warning disable 1573

    partial class GL
    {

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glActiveTexture")]
        public static 
        void ActiveTexture(OpenTK.Graphics.ES11.All texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ActiveTexture((OpenTK.Graphics.ES11.All)texture);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glAlphaFunc")]
        public static 
        void AlphaFunc(OpenTK.Graphics.ES11.All func, Single @ref)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.AlphaFunc((OpenTK.Graphics.ES11.All)func, (Single)@ref);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glAlphaFuncx")]
        public static 
        void AlphaFuncx(OpenTK.Graphics.ES11.All func, int @ref)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.AlphaFuncx((OpenTK.Graphics.ES11.All)func, (int)@ref);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindBuffer")]
        public static 
        void BindBuffer(OpenTK.Graphics.ES11.All target, Int32 buffer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BindBuffer((OpenTK.Graphics.ES11.All)target, (UInt32)buffer);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindBuffer")]
        public static 
        void BindBuffer(OpenTK.Graphics.ES11.All target, UInt32 buffer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BindBuffer((OpenTK.Graphics.ES11.All)target, (UInt32)buffer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindTexture")]
        public static 
        void BindTexture(OpenTK.Graphics.ES11.All target, Int32 texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BindTexture((OpenTK.Graphics.ES11.All)target, (UInt32)texture);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindTexture")]
        public static 
        void BindTexture(OpenTK.Graphics.ES11.All target, UInt32 texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BindTexture((OpenTK.Graphics.ES11.All)target, (UInt32)texture);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBlendFunc")]
        public static 
        void BlendFunc(OpenTK.Graphics.ES11.All sfactor, OpenTK.Graphics.ES11.All dfactor)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BlendFunc((OpenTK.Graphics.ES11.All)sfactor, (OpenTK.Graphics.ES11.All)dfactor);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferData")]
        public static 
        void BufferData<T2>(OpenTK.Graphics.ES11.All target, IntPtr size, [InAttribute, OutAttribute] ref T2 data, OpenTK.Graphics.ES11.All usage)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.Graphics.ES11.All)usage);
                data = (T2)data_ptr.Target;
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferData")]
        public static 
        void BufferData<T2>(OpenTK.Graphics.ES11.All target, IntPtr size, [InAttribute, OutAttribute] T2[,,] data, OpenTK.Graphics.ES11.All usage)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.Graphics.ES11.All)usage);
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferData")]
        public static 
        void BufferData<T2>(OpenTK.Graphics.ES11.All target, IntPtr size, [InAttribute, OutAttribute] T2[,] data, OpenTK.Graphics.ES11.All usage)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.Graphics.ES11.All)usage);
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferData")]
        public static 
        void BufferData<T2>(OpenTK.Graphics.ES11.All target, IntPtr size, [InAttribute, OutAttribute] T2[] data, OpenTK.Graphics.ES11.All usage)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject(), (OpenTK.Graphics.ES11.All)usage);
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferData")]
        public static 
        void BufferData(OpenTK.Graphics.ES11.All target, IntPtr size, IntPtr data, OpenTK.Graphics.ES11.All usage)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BufferData((OpenTK.Graphics.ES11.All)target, (IntPtr)size, (IntPtr)data, (OpenTK.Graphics.ES11.All)usage);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferSubData")]
        public static 
        void BufferSubData<T3>(OpenTK.Graphics.ES11.All target, IntPtr offset, IntPtr size, [InAttribute, OutAttribute] ref T3 data)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferSubData((OpenTK.Graphics.ES11.All)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
                data = (T3)data_ptr.Target;
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferSubData")]
        public static 
        void BufferSubData<T3>(OpenTK.Graphics.ES11.All target, IntPtr offset, IntPtr size, [InAttribute, OutAttribute] T3[,,] data)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferSubData((OpenTK.Graphics.ES11.All)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferSubData")]
        public static 
        void BufferSubData<T3>(OpenTK.Graphics.ES11.All target, IntPtr offset, IntPtr size, [InAttribute, OutAttribute] T3[,] data)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferSubData((OpenTK.Graphics.ES11.All)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferSubData")]
        public static 
        void BufferSubData<T3>(OpenTK.Graphics.ES11.All target, IntPtr offset, IntPtr size, [InAttribute, OutAttribute] T3[] data)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.BufferSubData((OpenTK.Graphics.ES11.All)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBufferSubData")]
        public static 
        void BufferSubData(OpenTK.Graphics.ES11.All target, IntPtr offset, IntPtr size, IntPtr data)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.BufferSubData((OpenTK.Graphics.ES11.All)target, (IntPtr)offset, (IntPtr)size, (IntPtr)data);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClear")]
        public static 
        void Clear(Int32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Clear((UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClear")]
        public static 
        void Clear(UInt32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Clear((UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClearColor")]
        public static 
        void ClearColor(Single red, Single green, Single blue, Single alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClearColor((Single)red, (Single)green, (Single)blue, (Single)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClearColorx")]
        public static 
        void ClearColorx(int red, int green, int blue, int alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClearColorx((int)red, (int)green, (int)blue, (int)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClearDepthf")]
        public static 
        void ClearDepth(Single depth)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClearDepthf((Single)depth);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClearDepthx")]
        public static 
        void ClearDepthx(int depth)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClearDepthx((int)depth);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClearStencil")]
        public static 
        void ClearStencil(Int32 s)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClearStencil((Int32)s);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClientActiveTexture")]
        public static 
        void ClientActiveTexture(OpenTK.Graphics.ES11.All texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClientActiveTexture((OpenTK.Graphics.ES11.All)texture);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanef")]
        public static 
        void ClipPlane(OpenTK.Graphics.ES11.All plane, ref Single equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* equation_ptr = &equation)
                {
                    Core.ClipPlanef((OpenTK.Graphics.ES11.All)plane, (Single*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanef")]
        public static 
        unsafe void ClipPlane(OpenTK.Graphics.ES11.All plane, Single* equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClipPlanef((OpenTK.Graphics.ES11.All)plane, (Single*)equation);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanef")]
        public static 
        void ClipPlane(OpenTK.Graphics.ES11.All plane, Single[] equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* equation_ptr = equation)
                {
                    Core.ClipPlanef((OpenTK.Graphics.ES11.All)plane, (Single*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanex")]
        public static 
        unsafe void ClipPlanex(OpenTK.Graphics.ES11.All plane, int* equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ClipPlanex((OpenTK.Graphics.ES11.All)plane, (int*)equation);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanex")]
        public static 
        void ClipPlanex(OpenTK.Graphics.ES11.All plane, int[] equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* equation_ptr = equation)
                {
                    Core.ClipPlanex((OpenTK.Graphics.ES11.All)plane, (int*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glClipPlanex")]
        public static 
        void ClipPlanex(OpenTK.Graphics.ES11.All plane, ref int equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* equation_ptr = &equation)
                {
                    Core.ClipPlanex((OpenTK.Graphics.ES11.All)plane, (int*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColor4f")]
        public static 
        void Color4(Single red, Single green, Single blue, Single alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Color4f((Single)red, (Single)green, (Single)blue, (Single)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColor4ub")]
        public static 
        void Color4(Byte red, Byte green, Byte blue, Byte alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Color4ub((Byte)red, (Byte)green, (Byte)blue, (Byte)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColor4x")]
        public static 
        void Color4x(int red, int green, int blue, int alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Color4x((int)red, (int)green, (int)blue, (int)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorMask")]
        public static 
        void ColorMask(bool red, bool green, bool blue, bool alpha)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ColorMask((bool)red, (bool)green, (bool)blue, (bool)alpha);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorPointer")]
        public static 
        void ColorPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T3 pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.ColorPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                pointer = (T3)pointer_ptr.Target;
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorPointer")]
        public static 
        void ColorPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.ColorPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorPointer")]
        public static 
        void ColorPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.ColorPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorPointer")]
        public static 
        void ColorPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.ColorPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glColorPointer")]
        public static 
        void ColorPointer(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ColorPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexImage2D")]
        public static 
        void CompressedTexImage2D<T7>(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [InAttribute, OutAttribute] ref T7 data)
            where T7 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                data = (T7)data_ptr.Target;
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexImage2D")]
        public static 
        void CompressedTexImage2D<T7>(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [InAttribute, OutAttribute] T7[,,] data)
            where T7 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexImage2D")]
        public static 
        void CompressedTexImage2D<T7>(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [InAttribute, OutAttribute] T7[,] data)
            where T7 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexImage2D")]
        public static 
        void CompressedTexImage2D<T7>(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, [InAttribute, OutAttribute] T7[] data)
            where T7 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexImage2D")]
        public static 
        void CompressedTexImage2D(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height, Int32 border, Int32 imageSize, IntPtr data)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.CompressedTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height, (Int32)border, (Int32)imageSize, (IntPtr)data);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexSubImage2D")]
        public static 
        void CompressedTexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, Int32 imageSize, [InAttribute, OutAttribute] ref T8 data)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
                data = (T8)data_ptr.Target;
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexSubImage2D")]
        public static 
        void CompressedTexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, Int32 imageSize, [InAttribute, OutAttribute] T8[,,] data)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexSubImage2D")]
        public static 
        void CompressedTexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, Int32 imageSize, [InAttribute, OutAttribute] T8[,] data)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexSubImage2D")]
        public static 
        void CompressedTexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, Int32 imageSize, [InAttribute, OutAttribute] T8[] data)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle data_ptr = GCHandle.Alloc(data, GCHandleType.Pinned);
            try
            {
                Core.CompressedTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (Int32)imageSize, (IntPtr)data_ptr.AddrOfPinnedObject());
            }
            finally
            {
                data_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCompressedTexSubImage2D")]
        public static 
        void CompressedTexSubImage2D(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, Int32 imageSize, IntPtr data)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.CompressedTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (Int32)imageSize, (IntPtr)data);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCopyTexImage2D")]
        public static 
        void CopyTexImage2D(OpenTK.Graphics.ES11.All target, Int32 level, OpenTK.Graphics.ES11.All internalformat, Int32 x, Int32 y, Int32 width, Int32 height, Int32 border)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.CopyTexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (OpenTK.Graphics.ES11.All)internalformat, (Int32)x, (Int32)y, (Int32)width, (Int32)height, (Int32)border);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCopyTexSubImage2D")]
        public static 
        void CopyTexSubImage2D(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 x, Int32 y, Int32 width, Int32 height)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.CopyTexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)x, (Int32)y, (Int32)width, (Int32)height);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCullFace")]
        public static 
        void CullFace(OpenTK.Graphics.ES11.All mode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.CullFace((OpenTK.Graphics.ES11.All)mode);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        unsafe void DeleteBuffers(Int32 n, Int32* buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DeleteBuffers((Int32)n, (UInt32*)buffers);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        void DeleteBuffers(Int32 n, Int32[] buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Core.DeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        void DeleteBuffers(Int32 n, ref Int32 buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Core.DeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        void DeleteBuffers(Int32 n, ref UInt32 buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Core.DeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        unsafe void DeleteBuffers(Int32 n, UInt32* buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DeleteBuffers((Int32)n, (UInt32*)buffers);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteBuffers")]
        public static 
        void DeleteBuffers(Int32 n, UInt32[] buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Core.DeleteBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        unsafe void DeleteTextures(Int32 n, Int32* textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DeleteTextures((Int32)n, (UInt32*)textures);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        void DeleteTextures(Int32 n, Int32[] textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Core.DeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        void DeleteTextures(Int32 n, ref Int32 textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Core.DeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        void DeleteTextures(Int32 n, ref UInt32 textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Core.DeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        unsafe void DeleteTextures(Int32 n, UInt32* textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DeleteTextures((Int32)n, (UInt32*)textures);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteTextures")]
        public static 
        void DeleteTextures(Int32 n, UInt32[] textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Core.DeleteTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDepthFunc")]
        public static 
        void DepthFunc(OpenTK.Graphics.ES11.All func)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DepthFunc((OpenTK.Graphics.ES11.All)func);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDepthMask")]
        public static 
        void DepthMask(bool flag)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DepthMask((bool)flag);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDepthRangef")]
        public static 
        void DepthRange(Single zNear, Single zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DepthRangef((Single)zNear, (Single)zFar);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDepthRangex")]
        public static 
        void DepthRangex(int zNear, int zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DepthRangex((int)zNear, (int)zFar);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDisable")]
        public static 
        void Disable(OpenTK.Graphics.ES11.All cap)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Disable((OpenTK.Graphics.ES11.All)cap);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDisableClientState")]
        public static 
        void DisableClientState(OpenTK.Graphics.ES11.All array)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DisableClientState((OpenTK.Graphics.ES11.All)array);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawArrays")]
        public static 
        void DrawArrays(OpenTK.Graphics.ES11.All mode, Int32 first, Int32 count)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DrawArrays((OpenTK.Graphics.ES11.All)mode, (Int32)first, (Int32)count);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawElements")]
        public static 
        void DrawElements<T3>(OpenTK.Graphics.ES11.All mode, Int32 count, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] ref T3 indices)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle indices_ptr = GCHandle.Alloc(indices, GCHandleType.Pinned);
            try
            {
                Core.DrawElements((OpenTK.Graphics.ES11.All)mode, (Int32)count, (OpenTK.Graphics.ES11.All)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
                indices = (T3)indices_ptr.Target;
            }
            finally
            {
                indices_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawElements")]
        public static 
        void DrawElements<T3>(OpenTK.Graphics.ES11.All mode, Int32 count, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T3[,,] indices)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle indices_ptr = GCHandle.Alloc(indices, GCHandleType.Pinned);
            try
            {
                Core.DrawElements((OpenTK.Graphics.ES11.All)mode, (Int32)count, (OpenTK.Graphics.ES11.All)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawElements")]
        public static 
        void DrawElements<T3>(OpenTK.Graphics.ES11.All mode, Int32 count, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T3[,] indices)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle indices_ptr = GCHandle.Alloc(indices, GCHandleType.Pinned);
            try
            {
                Core.DrawElements((OpenTK.Graphics.ES11.All)mode, (Int32)count, (OpenTK.Graphics.ES11.All)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawElements")]
        public static 
        void DrawElements<T3>(OpenTK.Graphics.ES11.All mode, Int32 count, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T3[] indices)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle indices_ptr = GCHandle.Alloc(indices, GCHandleType.Pinned);
            try
            {
                Core.DrawElements((OpenTK.Graphics.ES11.All)mode, (Int32)count, (OpenTK.Graphics.ES11.All)type, (IntPtr)indices_ptr.AddrOfPinnedObject());
            }
            finally
            {
                indices_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawElements")]
        public static 
        void DrawElements(OpenTK.Graphics.ES11.All mode, Int32 count, OpenTK.Graphics.ES11.All type, IntPtr indices)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.DrawElements((OpenTK.Graphics.ES11.All)mode, (Int32)count, (OpenTK.Graphics.ES11.All)type, (IntPtr)indices);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glEnable")]
        public static 
        void Enable(OpenTK.Graphics.ES11.All cap)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Enable((OpenTK.Graphics.ES11.All)cap);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glEnableClientState")]
        public static 
        void EnableClientState(OpenTK.Graphics.ES11.All array)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.EnableClientState((OpenTK.Graphics.ES11.All)array);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFinish")]
        public static 
        void Finish()
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Finish();
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFlush")]
        public static 
        void Flush()
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Flush();
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogf")]
        public static 
        void Fog(OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Fogf((OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogfv")]
        public static 
        unsafe void Fog(OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Fogfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogfv")]
        public static 
        void Fog(OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.Fogfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogx")]
        public static 
        void Fogx(OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Fogx((OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogxv")]
        public static 
        unsafe void Fogx(OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Fogxv((OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFogxv")]
        public static 
        void Fogx(OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.Fogxv((OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFrontFace")]
        public static 
        void FrontFace(OpenTK.Graphics.ES11.All mode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.FrontFace((OpenTK.Graphics.ES11.All)mode);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFrustumf")]
        public static 
        void Frustum(Single left, Single right, Single bottom, Single top, Single zNear, Single zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Frustumf((Single)left, (Single)right, (Single)bottom, (Single)top, (Single)zNear, (Single)zFar);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFrustumx")]
        public static 
        void Frustumx(int left, int right, int bottom, int top, int zNear, int zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Frustumx((int)left, (int)right, (int)bottom, (int)top, (int)zNear, (int)zFar);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        unsafe void GenBuffers(Int32 n, Int32* buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GenBuffers((Int32)n, (UInt32*)buffers);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        void GenBuffers(Int32 n, Int32[] buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* buffers_ptr = buffers)
                {
                    Core.GenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        void GenBuffers(Int32 n, ref Int32 buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* buffers_ptr = &buffers)
                {
                    Core.GenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        void GenBuffers(Int32 n, ref UInt32 buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* buffers_ptr = &buffers)
                {
                    Core.GenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        unsafe void GenBuffers(Int32 n, UInt32* buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GenBuffers((Int32)n, (UInt32*)buffers);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenBuffers")]
        public static 
        void GenBuffers(Int32 n, UInt32[] buffers)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* buffers_ptr = buffers)
                {
                    Core.GenBuffers((Int32)n, (UInt32*)buffers_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        unsafe void GenTextures(Int32 n, Int32* textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GenTextures((Int32)n, (UInt32*)textures);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        void GenTextures(Int32 n, Int32[] textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* textures_ptr = textures)
                {
                    Core.GenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        void GenTextures(Int32 n, ref Int32 textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* textures_ptr = &textures)
                {
                    Core.GenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        void GenTextures(Int32 n, ref UInt32 textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* textures_ptr = &textures)
                {
                    Core.GenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        unsafe void GenTextures(Int32 n, UInt32* textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GenTextures((Int32)n, (UInt32*)textures);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenTextures")]
        public static 
        void GenTextures(Int32 n, UInt32[] textures)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (UInt32* textures_ptr = textures)
                {
                    Core.GenTextures((Int32)n, (UInt32*)textures_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBooleanv")]
        public static 
        unsafe void GetBoolean(OpenTK.Graphics.ES11.All pname, bool* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetBooleanv((OpenTK.Graphics.ES11.All)pname, (bool*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBooleanv")]
        public static 
        void GetBoolean(OpenTK.Graphics.ES11.All pname, bool[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (bool* @params_ptr = @params)
                {
                    Core.GetBooleanv((OpenTK.Graphics.ES11.All)pname, (bool*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBooleanv")]
        public static 
        void GetBoolean(OpenTK.Graphics.ES11.All pname, ref bool @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (bool* @params_ptr = &@params)
                {
                    Core.GetBooleanv((OpenTK.Graphics.ES11.All)pname, (bool*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferParameteriv")]
        public static 
        unsafe void GetBufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetBufferParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferParameteriv")]
        public static 
        void GetBufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.GetBufferParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferParameteriv")]
        public static 
        void GetBufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, ref Int32 @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Core.GetBufferParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanef")]
        public static 
        void GetClipPlane(OpenTK.Graphics.ES11.All pname, ref Single equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* equation_ptr = &equation)
                {
                    Core.GetClipPlanef((OpenTK.Graphics.ES11.All)pname, (Single*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanef")]
        public static 
        unsafe void GetClipPlane(OpenTK.Graphics.ES11.All pname, Single* equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetClipPlanef((OpenTK.Graphics.ES11.All)pname, (Single*)equation);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanef")]
        public static 
        void GetClipPlane(OpenTK.Graphics.ES11.All pname, Single[] equation)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* equation_ptr = equation)
                {
                    Core.GetClipPlanef((OpenTK.Graphics.ES11.All)pname, (Single*)equation_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanex")]
        public static 
        unsafe void GetClipPlanex(OpenTK.Graphics.ES11.All pname, int* eqn)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetClipPlanex((OpenTK.Graphics.ES11.All)pname, (int*)eqn);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanex")]
        public static 
        void GetClipPlanex(OpenTK.Graphics.ES11.All pname, int[] eqn)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* eqn_ptr = eqn)
                {
                    Core.GetClipPlanex((OpenTK.Graphics.ES11.All)pname, (int*)eqn_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetClipPlanex")]
        public static 
        void GetClipPlanex(OpenTK.Graphics.ES11.All pname, ref int eqn)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* eqn_ptr = &eqn)
                {
                    Core.GetClipPlanex((OpenTK.Graphics.ES11.All)pname, (int*)eqn_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetError")]
        public static 
        OpenTK.Graphics.ES11.All GetError()
        {
            return Core.GetError();
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFixedv")]
        public static 
        unsafe void GetFixed(OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetFixedv((OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFixedv")]
        public static 
        void GetFixed(OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.GetFixedv((OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFixedv")]
        public static 
        void GetFixed(OpenTK.Graphics.ES11.All pname, ref int @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = &@params)
                {
                    Core.GetFixedv((OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFloatv")]
        public static 
        void GetFloat(OpenTK.Graphics.ES11.All pname, ref Single @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Core.GetFloatv((OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFloatv")]
        public static 
        unsafe void GetFloat(OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetFloatv((OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFloatv")]
        public static 
        void GetFloat(OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.GetFloatv((OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetIntegerv")]
        public static 
        unsafe void GetInteger(OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetIntegerv((OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetIntegerv")]
        public static 
        void GetInteger(OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.GetIntegerv((OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetIntegerv")]
        public static 
        void GetInteger(OpenTK.Graphics.ES11.All pname, ref Int32 @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Core.GetIntegerv((OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightfv")]
        public static 
        void GetLight(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, ref Single @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Core.GetLightfv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightfv")]
        public static 
        unsafe void GetLight(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetLightfv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightfv")]
        public static 
        void GetLight(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.GetLightfv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightxv")]
        public static 
        unsafe void GetLightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetLightxv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightxv")]
        public static 
        void GetLightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.GetLightxv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetLightxv")]
        public static 
        void GetLightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, ref int @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = &@params)
                {
                    Core.GetLightxv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialfv")]
        public static 
        void GetMaterial(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, ref Single @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Core.GetMaterialfv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialfv")]
        public static 
        unsafe void GetMaterial(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetMaterialfv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialfv")]
        public static 
        void GetMaterial(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.GetMaterialfv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialxv")]
        public static 
        unsafe void GetMaterialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetMaterialxv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialxv")]
        public static 
        void GetMaterialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.GetMaterialxv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetMaterialxv")]
        public static 
        void GetMaterialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, ref int @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = &@params)
                {
                    Core.GetMaterialxv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetPointerv")]
        public static 
        void GetPointer<T1>(OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] ref T1 @params)
            where T1 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
            try
            {
                Core.GetPointerv((OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                @params = (T1)@params_ptr.Target;
            }
            finally
            {
                @params_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetPointerv")]
        public static 
        void GetPointer<T1>(OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T1[,,] @params)
            where T1 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
            try
            {
                Core.GetPointerv((OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
            }
            finally
            {
                @params_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetPointerv")]
        public static 
        void GetPointer<T1>(OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T1[,] @params)
            where T1 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
            try
            {
                Core.GetPointerv((OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
            }
            finally
            {
                @params_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetPointerv")]
        public static 
        void GetPointer<T1>(OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T1[] @params)
            where T1 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
            try
            {
                Core.GetPointerv((OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
            }
            finally
            {
                @params_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetPointerv")]
        public static 
        void GetPointer(OpenTK.Graphics.ES11.All pname, IntPtr @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetPointerv((OpenTK.Graphics.ES11.All)pname, (IntPtr)@params);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetString")]
        public static 
        unsafe string GetString(OpenTK.Graphics.ES11.All name)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return System.Runtime.InteropServices.Marshal.PtrToStringAnsi(Core.GetString((OpenTK.Graphics.ES11.All)name));
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvfv")]
        public static 
        void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, ref Single @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Core.GetTexEnvfv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvfv")]
        public static 
        unsafe void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexEnvfv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvfv")]
        public static 
        void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.GetTexEnvfv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnviv")]
        public static 
        unsafe void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexEnviv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnviv")]
        public static 
        void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.GetTexEnviv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnviv")]
        public static 
        void GetTexEnv(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, ref Int32 @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Core.GetTexEnviv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvxv")]
        public static 
        unsafe void GetTexEnvx(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexEnvxv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvxv")]
        public static 
        void GetTexEnvx(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.GetTexEnvxv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexEnvxv")]
        public static 
        void GetTexEnvx(OpenTK.Graphics.ES11.All env, OpenTK.Graphics.ES11.All pname, ref int @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = &@params)
                {
                    Core.GetTexEnvxv((OpenTK.Graphics.ES11.All)env, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterfv")]
        public static 
        void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, ref Single @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = &@params)
                {
                    Core.GetTexParameterfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterfv")]
        public static 
        unsafe void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexParameterfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterfv")]
        public static 
        void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.GetTexParameterfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameteriv")]
        public static 
        unsafe void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameteriv")]
        public static 
        void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.GetTexParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameteriv")]
        public static 
        void GetTexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, ref Int32 @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = &@params)
                {
                    Core.GetTexParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterxv")]
        public static 
        unsafe void GetTexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.GetTexParameterxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterxv")]
        public static 
        void GetTexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.GetTexParameterxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetTexParameterxv")]
        public static 
        void GetTexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, ref int @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = &@params)
                {
                    Core.GetTexParameterxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glHint")]
        public static 
        void Hint(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All mode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Hint((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)mode);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsBuffer")]
        public static 
        bool IsBuffer(Int32 buffer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return Core.IsBuffer((UInt32)buffer);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsBuffer")]
        public static 
        bool IsBuffer(UInt32 buffer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return Core.IsBuffer((UInt32)buffer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsEnabled")]
        public static 
        bool IsEnabled(OpenTK.Graphics.ES11.All cap)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return Core.IsEnabled((OpenTK.Graphics.ES11.All)cap);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsTexture")]
        public static 
        bool IsTexture(Int32 texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return Core.IsTexture((UInt32)texture);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsTexture")]
        public static 
        bool IsTexture(UInt32 texture)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            return Core.IsTexture((UInt32)texture);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightf")]
        public static 
        void Light(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Lightf((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightfv")]
        public static 
        unsafe void Light(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Lightfv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightfv")]
        public static 
        void Light(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.Lightfv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelf")]
        public static 
        void LightModel(OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LightModelf((OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelfv")]
        public static 
        unsafe void LightModel(OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LightModelfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelfv")]
        public static 
        void LightModel(OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.LightModelfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelx")]
        public static 
        void LightModelx(OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LightModelx((OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelxv")]
        public static 
        unsafe void LightModelx(OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LightModelxv((OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightModelxv")]
        public static 
        void LightModelx(OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.LightModelxv((OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightx")]
        public static 
        void Lightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Lightx((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightxv")]
        public static 
        unsafe void Lightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Lightxv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLightxv")]
        public static 
        void Lightx(OpenTK.Graphics.ES11.All light, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.Lightxv((OpenTK.Graphics.ES11.All)light, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLineWidth")]
        public static 
        void LineWidth(Single width)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LineWidth((Single)width);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLineWidthx")]
        public static 
        void LineWidthx(int width)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LineWidthx((int)width);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadIdentity")]
        public static 
        void LoadIdentity()
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LoadIdentity();
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixf")]
        public static 
        void LoadMatrix(ref Single m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Core.LoadMatrixf((Single*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixf")]
        public static 
        unsafe void LoadMatrix(Single* m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LoadMatrixf((Single*)m);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixf")]
        public static 
        void LoadMatrix(Single[] m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Core.LoadMatrixf((Single*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixx")]
        public static 
        unsafe void LoadMatrixx(int* m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LoadMatrixx((int*)m);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixx")]
        public static 
        void LoadMatrixx(int[] m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* m_ptr = m)
                {
                    Core.LoadMatrixx((int*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadMatrixx")]
        public static 
        void LoadMatrixx(ref int m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* m_ptr = &m)
                {
                    Core.LoadMatrixx((int*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLogicOp")]
        public static 
        void LogicOp(OpenTK.Graphics.ES11.All opcode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.LogicOp((OpenTK.Graphics.ES11.All)opcode);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialf")]
        public static 
        void Material(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Materialf((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialfv")]
        public static 
        unsafe void Material(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Materialfv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialfv")]
        public static 
        void Material(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.Materialfv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialx")]
        public static 
        void Materialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Materialx((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialxv")]
        public static 
        unsafe void Materialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Materialxv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMaterialxv")]
        public static 
        void Materialx(OpenTK.Graphics.ES11.All face, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.Materialxv((OpenTK.Graphics.ES11.All)face, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixMode")]
        public static 
        void MatrixMode(OpenTK.Graphics.ES11.All mode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.MatrixMode((OpenTK.Graphics.ES11.All)mode);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultiTexCoord4f")]
        public static 
        void MultiTexCoord4(OpenTK.Graphics.ES11.All target, Single s, Single t, Single r, Single q)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.MultiTexCoord4f((OpenTK.Graphics.ES11.All)target, (Single)s, (Single)t, (Single)r, (Single)q);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultiTexCoord4x")]
        public static 
        void MultiTexCoord4x(OpenTK.Graphics.ES11.All target, int s, int t, int r, int q)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.MultiTexCoord4x((OpenTK.Graphics.ES11.All)target, (int)s, (int)t, (int)r, (int)q);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixf")]
        public static 
        void MultMatrix(ref Single m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* m_ptr = &m)
                {
                    Core.MultMatrixf((Single*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixf")]
        public static 
        unsafe void MultMatrix(Single* m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.MultMatrixf((Single*)m);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixf")]
        public static 
        void MultMatrix(Single[] m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* m_ptr = m)
                {
                    Core.MultMatrixf((Single*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixx")]
        public static 
        unsafe void MultMatrixx(int* m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.MultMatrixx((int*)m);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixx")]
        public static 
        void MultMatrixx(int[] m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* m_ptr = m)
                {
                    Core.MultMatrixx((int*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMultMatrixx")]
        public static 
        void MultMatrixx(ref int m)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* m_ptr = &m)
                {
                    Core.MultMatrixx((int*)m_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormal3f")]
        public static 
        void Normal3(Single nx, Single ny, Single nz)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Normal3f((Single)nx, (Single)ny, (Single)nz);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormal3x")]
        public static 
        void Normal3x(int nx, int ny, int nz)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Normal3x((int)nx, (int)ny, (int)nz);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormalPointer")]
        public static 
        void NormalPointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T2 pointer)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.NormalPointer((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                pointer = (T2)pointer_ptr.Target;
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormalPointer")]
        public static 
        void NormalPointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[,,] pointer)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.NormalPointer((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormalPointer")]
        public static 
        void NormalPointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[,] pointer)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.NormalPointer((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormalPointer")]
        public static 
        void NormalPointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[] pointer)
            where T2 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.NormalPointer((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glNormalPointer")]
        public static 
        void NormalPointer(OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.NormalPointer((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glOrthof")]
        public static 
        void Ortho(Single left, Single right, Single bottom, Single top, Single zNear, Single zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Orthof((Single)left, (Single)right, (Single)bottom, (Single)top, (Single)zNear, (Single)zFar);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glOrthox")]
        public static 
        void Orthox(int left, int right, int bottom, int top, int zNear, int zFar)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Orthox((int)left, (int)right, (int)bottom, (int)top, (int)zNear, (int)zFar);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPixelStorei")]
        public static 
        void PixelStore(OpenTK.Graphics.ES11.All pname, Int32 param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PixelStorei((OpenTK.Graphics.ES11.All)pname, (Int32)param);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterf")]
        public static 
        void PointParameter(OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointParameterf((OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterfv")]
        public static 
        unsafe void PointParameter(OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointParameterfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterfv")]
        public static 
        void PointParameter(OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.PointParameterfv((OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterx")]
        public static 
        void PointParameterx(OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointParameterx((OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterxv")]
        public static 
        unsafe void PointParameterx(OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointParameterxv((OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointParameterxv")]
        public static 
        void PointParameterx(OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.PointParameterxv((OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSize")]
        public static 
        void PointSize(Single size)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointSize((Single)size);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizex")]
        public static 
        void PointSizex(int size)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PointSizex((int)size);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPolygonOffset")]
        public static 
        void PolygonOffset(Single factor, Single units)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PolygonOffset((Single)factor, (Single)units);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPolygonOffsetx")]
        public static 
        void PolygonOffsetx(int factor, int units)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PolygonOffsetx((int)factor, (int)units);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPopMatrix")]
        public static 
        void PopMatrix()
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PopMatrix();
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPushMatrix")]
        public static 
        void PushMatrix()
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.PushMatrix();
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glReadPixels")]
        public static 
        void ReadPixels<T6>(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] ref T6 pixels)
            where T6 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.ReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                pixels = (T6)pixels_ptr.Target;
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glReadPixels")]
        public static 
        void ReadPixels<T6>(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T6[,,] pixels)
            where T6 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.ReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glReadPixels")]
        public static 
        void ReadPixels<T6>(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T6[,] pixels)
            where T6 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.ReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glReadPixels")]
        public static 
        void ReadPixels<T6>(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T6[] pixels)
            where T6 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.ReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glReadPixels")]
        public static 
        void ReadPixels(Int32 x, Int32 y, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, IntPtr pixels)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ReadPixels((Int32)x, (Int32)y, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glRotatef")]
        public static 
        void Rotate(Single angle, Single x, Single y, Single z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Rotatef((Single)angle, (Single)x, (Single)y, (Single)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glRotatex")]
        public static 
        void Rotatex(int angle, int x, int y, int z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Rotatex((int)angle, (int)x, (int)y, (int)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glSampleCoverage")]
        public static 
        void SampleCoverage(Single value, bool invert)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.SampleCoverage((Single)value, (bool)invert);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glSampleCoveragex")]
        public static 
        void SampleCoveragex(int value, bool invert)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.SampleCoveragex((int)value, (bool)invert);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glScalef")]
        public static 
        void Scale(Single x, Single y, Single z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Scalef((Single)x, (Single)y, (Single)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glScalex")]
        public static 
        void Scalex(int x, int y, int z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Scalex((int)x, (int)y, (int)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glScissor")]
        public static 
        void Scissor(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Scissor((Int32)x, (Int32)y, (Int32)width, (Int32)height);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glShadeModel")]
        public static 
        void ShadeModel(OpenTK.Graphics.ES11.All mode)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.ShadeModel((OpenTK.Graphics.ES11.All)mode);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glStencilFunc")]
        public static 
        void StencilFunc(OpenTK.Graphics.ES11.All func, Int32 @ref, Int32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.StencilFunc((OpenTK.Graphics.ES11.All)func, (Int32)@ref, (UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glStencilFunc")]
        public static 
        void StencilFunc(OpenTK.Graphics.ES11.All func, Int32 @ref, UInt32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.StencilFunc((OpenTK.Graphics.ES11.All)func, (Int32)@ref, (UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glStencilMask")]
        public static 
        void StencilMask(Int32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.StencilMask((UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glStencilMask")]
        public static 
        void StencilMask(UInt32 mask)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.StencilMask((UInt32)mask);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glStencilOp")]
        public static 
        void StencilOp(OpenTK.Graphics.ES11.All fail, OpenTK.Graphics.ES11.All zfail, OpenTK.Graphics.ES11.All zpass)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.StencilOp((OpenTK.Graphics.ES11.All)fail, (OpenTK.Graphics.ES11.All)zfail, (OpenTK.Graphics.ES11.All)zpass);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexCoordPointer")]
        public static 
        void TexCoordPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T3 pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.TexCoordPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                pointer = (T3)pointer_ptr.Target;
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexCoordPointer")]
        public static 
        void TexCoordPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.TexCoordPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexCoordPointer")]
        public static 
        void TexCoordPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.TexCoordPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexCoordPointer")]
        public static 
        void TexCoordPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.TexCoordPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexCoordPointer")]
        public static 
        void TexCoordPointer(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexCoordPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvf")]
        public static 
        void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnvf((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvfv")]
        public static 
        unsafe void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnvfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvfv")]
        public static 
        void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.TexEnvfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvi")]
        public static 
        void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32 param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnvi((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnviv")]
        public static 
        unsafe void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnviv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnviv")]
        public static 
        void TexEnv(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.TexEnviv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvx")]
        public static 
        void TexEnvx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnvx((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvxv")]
        public static 
        unsafe void TexEnvx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexEnvxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexEnvxv")]
        public static 
        void TexEnvx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.TexEnvxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexImage2D")]
        public static 
        void TexImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] ref T8 pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                pixels = (T8)pixels_ptr.Target;
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexImage2D")]
        public static 
        void TexImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[,,] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexImage2D")]
        public static 
        void TexImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[,] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexImage2D")]
        public static 
        void TexImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexImage2D")]
        public static 
        void TexImage2D(OpenTK.Graphics.ES11.All target, Int32 level, Int32 internalformat, Int32 width, Int32 height, Int32 border, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, IntPtr pixels)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)internalformat, (Int32)width, (Int32)height, (Int32)border, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterf")]
        public static 
        void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameterf((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterfv")]
        public static 
        unsafe void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameterfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterfv")]
        public static 
        void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Single[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Single* @params_ptr = @params)
                {
                    Core.TexParameterfv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Single*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameteri")]
        public static 
        void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32 param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameteri((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameteriv")]
        public static 
        unsafe void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameteriv")]
        public static 
        void TexParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (Int32* @params_ptr = @params)
                {
                    Core.TexParameteriv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterx")]
        public static 
        void TexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int param)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameterx((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int)param);
            #if DEBUG
            }
            #endif
        }

        [System.CLSCompliant(false)]
        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterxv")]
        public static 
        unsafe void TexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int* @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexParameterxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexParameterxv")]
        public static 
        void TexParameterx(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, int[] @params)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            unsafe
            {
                fixed (int* @params_ptr = @params)
                {
                    Core.TexParameterxv((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (int*)@params_ptr);
                }
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexSubImage2D")]
        public static 
        void TexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] ref T8 pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
                pixels = (T8)pixels_ptr.Target;
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexSubImage2D")]
        public static 
        void TexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[,,] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexSubImage2D")]
        public static 
        void TexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[,] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexSubImage2D")]
        public static 
        void TexSubImage2D<T8>(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, [InAttribute, OutAttribute] T8[] pixels)
            where T8 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pixels_ptr = GCHandle.Alloc(pixels, GCHandleType.Pinned);
            try
            {
                Core.TexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pixels_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTexSubImage2D")]
        public static 
        void TexSubImage2D(OpenTK.Graphics.ES11.All target, Int32 level, Int32 xoffset, Int32 yoffset, Int32 width, Int32 height, OpenTK.Graphics.ES11.All format, OpenTK.Graphics.ES11.All type, IntPtr pixels)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.TexSubImage2D((OpenTK.Graphics.ES11.All)target, (Int32)level, (Int32)xoffset, (Int32)yoffset, (Int32)width, (Int32)height, (OpenTK.Graphics.ES11.All)format, (OpenTK.Graphics.ES11.All)type, (IntPtr)pixels);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTranslatef")]
        public static 
        void Translate(Single x, Single y, Single z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Translatef((Single)x, (Single)y, (Single)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glTranslatex")]
        public static 
        void Translatex(int x, int y, int z)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Translatex((int)x, (int)y, (int)z);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glVertexPointer")]
        public static 
        void VertexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T3 pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.VertexPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                pointer = (T3)pointer_ptr.Target;
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glVertexPointer")]
        public static 
        void VertexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.VertexPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glVertexPointer")]
        public static 
        void VertexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.VertexPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glVertexPointer")]
        public static 
        void VertexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[] pointer)
            where T3 : struct
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
            try
            {
                Core.VertexPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
            }
            finally
            {
                pointer_ptr.Free();
            }
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glVertexPointer")]
        public static 
        void VertexPointer(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.VertexPointer((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
            #if DEBUG
            }
            #endif
        }

        [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glViewport")]
        public static 
        void Viewport(Int32 x, Int32 y, Int32 width, Int32 height)
        {
            #if DEBUG
            using (new ErrorHelper(GraphicsContext.CurrentContext))
            {
            #endif
            Core.Viewport((Int32)x, (Int32)y, (Int32)width, (Int32)height);
            #if DEBUG
            }
            #endif
        }

        public static partial class Oes
        {
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindFramebufferOES")]
            public static 
            void BindFramebuffer(OpenTK.Graphics.ES11.All target, Int32 framebuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BindFramebufferOES((OpenTK.Graphics.ES11.All)target, (UInt32)framebuffer);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindFramebufferOES")]
            public static 
            void BindFramebuffer(OpenTK.Graphics.ES11.All target, UInt32 framebuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BindFramebufferOES((OpenTK.Graphics.ES11.All)target, (UInt32)framebuffer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindRenderbufferOES")]
            public static 
            void BindRenderbuffer(OpenTK.Graphics.ES11.All target, Int32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BindRenderbufferOES((OpenTK.Graphics.ES11.All)target, (UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBindRenderbufferOES")]
            public static 
            void BindRenderbuffer(OpenTK.Graphics.ES11.All target, UInt32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BindRenderbufferOES((OpenTK.Graphics.ES11.All)target, (UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBlendEquationOES")]
            public static 
            void BlendEquation(OpenTK.Graphics.ES11.All mode)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BlendEquationOES((OpenTK.Graphics.ES11.All)mode);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBlendEquationSeparateOES")]
            public static 
            void BlendEquationSeparate(OpenTK.Graphics.ES11.All modeRGB, OpenTK.Graphics.ES11.All modeAlpha)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BlendEquationSeparateOES((OpenTK.Graphics.ES11.All)modeRGB, (OpenTK.Graphics.ES11.All)modeAlpha);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glBlendFuncSeparateOES")]
            public static 
            void BlendFuncSeparate(OpenTK.Graphics.ES11.All srcRGB, OpenTK.Graphics.ES11.All dstRGB, OpenTK.Graphics.ES11.All srcAlpha, OpenTK.Graphics.ES11.All dstAlpha)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.BlendFuncSeparateOES((OpenTK.Graphics.ES11.All)srcRGB, (OpenTK.Graphics.ES11.All)dstRGB, (OpenTK.Graphics.ES11.All)srcAlpha, (OpenTK.Graphics.ES11.All)dstAlpha);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCheckFramebufferStatusOES")]
            public static 
            OpenTK.Graphics.ES11.All CheckFramebufferStatus(OpenTK.Graphics.ES11.All target)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.CheckFramebufferStatusOES((OpenTK.Graphics.ES11.All)target);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCurrentPaletteMatrixOES")]
            public static 
            void CurrentPaletteMatrix(Int32 matrixpaletteindex)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.CurrentPaletteMatrixOES((UInt32)matrixpaletteindex);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glCurrentPaletteMatrixOES")]
            public static 
            void CurrentPaletteMatrix(UInt32 matrixpaletteindex)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.CurrentPaletteMatrixOES((UInt32)matrixpaletteindex);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            unsafe void DeleteFramebuffers(Int32 n, Int32* framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            void DeleteFramebuffers(Int32 n, Int32[] framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            void DeleteFramebuffers(Int32 n, ref Int32 framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            void DeleteFramebuffers(Int32 n, ref UInt32 framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = &framebuffers)
                    {
                        Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            unsafe void DeleteFramebuffers(Int32 n, UInt32* framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteFramebuffersOES")]
            public static 
            void DeleteFramebuffers(Int32 n, UInt32[] framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = framebuffers)
                    {
                        Core.DeleteFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            unsafe void DeleteRenderbuffers(Int32 n, Int32* renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            void DeleteRenderbuffers(Int32 n, Int32[] renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            void DeleteRenderbuffers(Int32 n, ref Int32 renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            void DeleteRenderbuffers(Int32 n, ref UInt32 renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                    {
                        Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            unsafe void DeleteRenderbuffers(Int32 n, UInt32* renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDeleteRenderbuffersOES")]
            public static 
            void DeleteRenderbuffers(Int32 n, UInt32[] renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = renderbuffers)
                    {
                        Core.DeleteRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexfOES")]
            public static 
            void DrawTex(Single x, Single y, Single z, Single width, Single height)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexfOES((Single)x, (Single)y, (Single)z, (Single)width, (Single)height);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexfvOES")]
            public static 
            void DrawTex(ref Single coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Single* coords_ptr = &coords)
                    {
                        Core.DrawTexfvOES((Single*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexfvOES")]
            public static 
            unsafe void DrawTex(Single* coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexfvOES((Single*)coords);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexfvOES")]
            public static 
            void DrawTex(Single[] coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Single* coords_ptr = coords)
                    {
                        Core.DrawTexfvOES((Single*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexiOES")]
            public static 
            void DrawTex(Int32 x, Int32 y, Int32 z, Int32 width, Int32 height)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexiOES((Int32)x, (Int32)y, (Int32)z, (Int32)width, (Int32)height);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexivOES")]
            public static 
            unsafe void DrawTex(Int32* coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexivOES((Int32*)coords);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexivOES")]
            public static 
            void DrawTex(Int32[] coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* coords_ptr = coords)
                    {
                        Core.DrawTexivOES((Int32*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexivOES")]
            public static 
            void DrawTex(ref Int32 coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* coords_ptr = &coords)
                    {
                        Core.DrawTexivOES((Int32*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexsOES")]
            public static 
            void DrawTex(Int16 x, Int16 y, Int16 z, Int16 width, Int16 height)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexsOES((Int16)x, (Int16)y, (Int16)z, (Int16)width, (Int16)height);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexsvOES")]
            public static 
            unsafe void DrawTex(Int16* coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexsvOES((Int16*)coords);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexsvOES")]
            public static 
            void DrawTex(Int16[] coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int16* coords_ptr = coords)
                    {
                        Core.DrawTexsvOES((Int16*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexsvOES")]
            public static 
            void DrawTex(ref Int16 coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int16* coords_ptr = &coords)
                    {
                        Core.DrawTexsvOES((Int16*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexxOES")]
            public static 
            void DrawTexx(int x, int y, int z, int width, int height)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexxOES((int)x, (int)y, (int)z, (int)width, (int)height);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexxvOES")]
            public static 
            unsafe void DrawTexx(int* coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.DrawTexxvOES((int*)coords);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexxvOES")]
            public static 
            void DrawTexx(int[] coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (int* coords_ptr = coords)
                    {
                        Core.DrawTexxvOES((int*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glDrawTexxvOES")]
            public static 
            void DrawTexx(ref int coords)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (int* coords_ptr = &coords)
                    {
                        Core.DrawTexxvOES((int*)coords_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFramebufferRenderbufferOES")]
            public static 
            void FramebufferRenderbuffer(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All renderbuffertarget, Int32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.FramebufferRenderbufferOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)renderbuffertarget, (UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFramebufferRenderbufferOES")]
            public static 
            void FramebufferRenderbuffer(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All renderbuffertarget, UInt32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.FramebufferRenderbufferOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)renderbuffertarget, (UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFramebufferTexture2DOES")]
            public static 
            void FramebufferTexture2D(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All textarget, Int32 texture, Int32 level)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.FramebufferTexture2DOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)textarget, (UInt32)texture, (Int32)level);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glFramebufferTexture2DOES")]
            public static 
            void FramebufferTexture2D(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All textarget, UInt32 texture, Int32 level)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.FramebufferTexture2DOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)textarget, (UInt32)texture, (Int32)level);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenerateMipmapOES")]
            public static 
            void GenerateMipmap(OpenTK.Graphics.ES11.All target)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GenerateMipmapOES((OpenTK.Graphics.ES11.All)target);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            unsafe void GenFramebuffers(Int32 n, Int32* framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            void GenFramebuffers(Int32 n, Int32[] framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = framebuffers)
                    {
                        Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            void GenFramebuffers(Int32 n, ref Int32 framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* framebuffers_ptr = &framebuffers)
                    {
                        Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            void GenFramebuffers(Int32 n, ref UInt32 framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = &framebuffers)
                    {
                        Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            unsafe void GenFramebuffers(Int32 n, UInt32* framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenFramebuffersOES")]
            public static 
            void GenFramebuffers(Int32 n, UInt32[] framebuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* framebuffers_ptr = framebuffers)
                    {
                        Core.GenFramebuffersOES((Int32)n, (UInt32*)framebuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            unsafe void GenRenderbuffers(Int32 n, Int32* renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            void GenRenderbuffers(Int32 n, Int32[] renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = renderbuffers)
                    {
                        Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            void GenRenderbuffers(Int32 n, ref Int32 renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* renderbuffers_ptr = &renderbuffers)
                    {
                        Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            void GenRenderbuffers(Int32 n, ref UInt32 renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = &renderbuffers)
                    {
                        Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            unsafe void GenRenderbuffers(Int32 n, UInt32* renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGenRenderbuffersOES")]
            public static 
            void GenRenderbuffers(Int32 n, UInt32[] renderbuffers)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (UInt32* renderbuffers_ptr = renderbuffers)
                    {
                        Core.GenRenderbuffersOES((Int32)n, (UInt32*)renderbuffers_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferPointervOES")]
            public static 
            void GetBufferPointer<T2>(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] ref T2 @params)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
                try
                {
                    Core.GetBufferPointervOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                    @params = (T2)@params_ptr.Target;
                }
                finally
                {
                    @params_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferPointervOES")]
            public static 
            void GetBufferPointer<T2>(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T2[,,] @params)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
                try
                {
                    Core.GetBufferPointervOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferPointervOES")]
            public static 
            void GetBufferPointer<T2>(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T2[,] @params)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
                try
                {
                    Core.GetBufferPointervOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferPointervOES")]
            public static 
            void GetBufferPointer<T2>(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, [InAttribute, OutAttribute] T2[] @params)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle @params_ptr = GCHandle.Alloc(@params, GCHandleType.Pinned);
                try
                {
                    Core.GetBufferPointervOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (IntPtr)@params_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    @params_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetBufferPointervOES")]
            public static 
            void GetBufferPointer(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, IntPtr @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GetBufferPointervOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (IntPtr)@params);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFramebufferAttachmentParameterivOES")]
            public static 
            unsafe void GetFramebufferAttachmentParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All pname, Int32* @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GetFramebufferAttachmentParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFramebufferAttachmentParameterivOES")]
            public static 
            void GetFramebufferAttachmentParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All pname, Int32[] @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Core.GetFramebufferAttachmentParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetFramebufferAttachmentParameterivOES")]
            public static 
            void GetFramebufferAttachmentParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All attachment, OpenTK.Graphics.ES11.All pname, ref Int32 @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Core.GetFramebufferAttachmentParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)attachment, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetRenderbufferParameterivOES")]
            public static 
            unsafe void GetRenderbufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32* @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.GetRenderbufferParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetRenderbufferParameterivOES")]
            public static 
            void GetRenderbufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, Int32[] @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* @params_ptr = @params)
                    {
                        Core.GetRenderbufferParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glGetRenderbufferParameterivOES")]
            public static 
            void GetRenderbufferParameter(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All pname, ref Int32 @params)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                unsafe
                {
                    fixed (Int32* @params_ptr = &@params)
                    {
                        Core.GetRenderbufferParameterivOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)pname, (Int32*)@params_ptr);
                    }
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsFramebufferOES")]
            public static 
            bool IsFramebuffer(Int32 framebuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.IsFramebufferOES((UInt32)framebuffer);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsFramebufferOES")]
            public static 
            bool IsFramebuffer(UInt32 framebuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.IsFramebufferOES((UInt32)framebuffer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsRenderbufferOES")]
            public static 
            bool IsRenderbuffer(Int32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.IsRenderbufferOES((UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glIsRenderbufferOES")]
            public static 
            bool IsRenderbuffer(UInt32 renderbuffer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.IsRenderbufferOES((UInt32)renderbuffer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glLoadPaletteFromModelViewMatrixOES")]
            public static 
            void LoadPaletteFromModelViewMatrix()
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.LoadPaletteFromModelViewMatrixOES();
                #if DEBUG
                }
                #endif
            }

            [System.CLSCompliant(false)]
            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMapBufferOES")]
            public static 
            unsafe IntPtr MapBuffer(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All access)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.MapBufferOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)access);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixIndexPointerOES")]
            public static 
            void MatrixIndexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T3 pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.MatrixIndexPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                    pointer = (T3)pointer_ptr.Target;
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixIndexPointerOES")]
            public static 
            void MatrixIndexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,,] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.MatrixIndexPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixIndexPointerOES")]
            public static 
            void MatrixIndexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.MatrixIndexPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixIndexPointerOES")]
            public static 
            void MatrixIndexPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.MatrixIndexPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glMatrixIndexPointerOES")]
            public static 
            void MatrixIndexPointer(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.MatrixIndexPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizePointerOES")]
            public static 
            void PointSizePointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T2 pointer)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.PointSizePointerOES((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                    pointer = (T2)pointer_ptr.Target;
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizePointerOES")]
            public static 
            void PointSizePointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[,,] pointer)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.PointSizePointerOES((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizePointerOES")]
            public static 
            void PointSizePointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[,] pointer)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.PointSizePointerOES((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizePointerOES")]
            public static 
            void PointSizePointer<T2>(OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T2[] pointer)
                where T2 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.PointSizePointerOES((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glPointSizePointerOES")]
            public static 
            void PointSizePointer(OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.PointSizePointerOES((OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glRenderbufferStorageOES")]
            public static 
            void RenderbufferStorage(OpenTK.Graphics.ES11.All target, OpenTK.Graphics.ES11.All internalformat, Int32 width, Int32 height)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.RenderbufferStorageOES((OpenTK.Graphics.ES11.All)target, (OpenTK.Graphics.ES11.All)internalformat, (Int32)width, (Int32)height);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glUnmapBufferOES")]
            public static 
            bool UnmapBuffer(OpenTK.Graphics.ES11.All target)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                return Core.UnmapBufferOES((OpenTK.Graphics.ES11.All)target);
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glWeightPointerOES")]
            public static 
            void WeightPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] ref T3 pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.WeightPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                    pointer = (T3)pointer_ptr.Target;
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glWeightPointerOES")]
            public static 
            void WeightPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,,] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.WeightPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glWeightPointerOES")]
            public static 
            void WeightPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[,] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.WeightPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glWeightPointerOES")]
            public static 
            void WeightPointer<T3>(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, [InAttribute, OutAttribute] T3[] pointer)
                where T3 : struct
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                GCHandle pointer_ptr = GCHandle.Alloc(pointer, GCHandleType.Pinned);
                try
                {
                    Core.WeightPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer_ptr.AddrOfPinnedObject());
                }
                finally
                {
                    pointer_ptr.Free();
                }
                #if DEBUG
                }
                #endif
            }

            [AutoGenerated(Category = "1.1", Version = "1.1", EntryPoint = "glWeightPointerOES")]
            public static 
            void WeightPointer(Int32 size, OpenTK.Graphics.ES11.All type, Int32 stride, IntPtr pointer)
            {
                #if DEBUG
                using (new ErrorHelper(GraphicsContext.CurrentContext))
                {
                #endif
                Core.WeightPointerOES((Int32)size, (OpenTK.Graphics.ES11.All)type, (Int32)stride, (IntPtr)pointer);
                #if DEBUG
                }
                #endif
            }

        }

    }
}
